home *** CD-ROM | disk | FTP | other *** search
/ Cobra Utilities for Doom & Doom II / Cobra Utilities For Doom & Doom II - Disc 2.iso / files / program / ibsp101s / wadfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-10  |  9.1 KB  |  419 lines
  1. #include "idbsp.h"
  2. #include <ctype.h>
  3.  
  4. typedef struct
  5.     {
  6.     char                identification[4];    /* should be IWAD */
  7.     int                 numlumps;
  8.     int                 infotableofs;
  9.     }
  10.  
  11. wadinfo_t;
  12.  
  13.  
  14. typedef struct
  15.     {
  16.     int                 filepos;
  17.     int                 size;
  18.     char                name[8];
  19.     }
  20.  
  21. lumpinfo_t;
  22.  
  23.  
  24. /*
  25.    =============================================================================
  26.  */
  27.  
  28. /*
  29.    ============
  30.    =
  31.    = initFromFile:
  32.    =
  33.    ============
  34.  */
  35.  
  36. /* WADFILE *initFromFile(WADFILE *self,char const *path) */
  37. void                initFromFile(void)
  38. {
  39.     wadinfo_t           wad;
  40.     lumpinfo_t         *lumps;
  41.     int                 i;
  42.  
  43. /*
  44.    self->pathname = malloc(strlen(path)+1);
  45.    strcpy (self->pathname, path);
  46.    self->dirty = false;
  47.    self->handle = open (self->pathname, O_RDWR, 0666);
  48.    if (self->handle== -1)
  49.    {
  50.    /*              [self free]; */
  51. /*    return nil; */
  52. /*
  53.    WadfileFree(self);
  54.    return NULL;
  55.    }
  56.  */
  57. /*
  58.    read in the header
  59.  */
  60. /*              read (self->handle, &wad, sizeof(wad)); */
  61.     fread(&wad, sizeof(wad), 1, wad_i.handle);
  62.     if (strncmp(wad.identification, "PWAD", 4))
  63.         {
  64. /*
  65.    close (self->handle);
  66.    WadfileFree(self);
  67.    return NULL;
  68.  */
  69.         Error("\ninitFromFile: specified WAD is not a PWAD");
  70.         }
  71. /*
  72.    wad.numlumps = LONG (wad.numlumps);
  73.    wad.infotableofs = LONG (wad.infotableofs);
  74.  */
  75. /*
  76.    read in the lumpinfo
  77.  */
  78. /*              lseek (self->handle, wad.infotableofs, SEEK_SET); */
  79.     fseek(wad_i.handle, wad.infotableofs, SEEK_SET);
  80. /*
  81.    info = [[Storage alloc] initCount: wad.numlumps elementSize: sizeof(lumpinfo_t) description: ""];
  82.    lumps = [info elementAt: 0];
  83.  */
  84.     wad_i.info = (STORAGE *) SafeMalloc(sizeof(STORAGE));
  85.     wad_i.info -> data = (lumpinfo_t *) SafeCalloc(wad.numlumps, sizeof(lumpinfo_t));
  86.     wad_i.info -> count = wad.numlumps;
  87.     wad_i.info -> size = sizeof(lumpinfo_t);
  88.     lumps = wad_i.info -> data;
  89.  
  90. /*              read (self->handle, lumps, wad.numlumps*sizeof(lumpinfo_t)); */
  91.     fread(lumps, sizeof(lumpinfo_t), wad.numlumps, wad_i.handle);
  92. /*
  93.    for (i=0 ; i<wad.numlumps ; i++, lumps++)
  94.    {
  95.    lumps->filepos = LONG (lumps->filepos);
  96.    lumps->size = LONG (lumps->size);
  97.    }
  98.  */
  99.     return;
  100. }
  101.  
  102.  
  103. /*
  104.    ============
  105.    =
  106.    = initNew:
  107.    =
  108.    ============
  109.  */
  110.  
  111. void                initNew(void)
  112. {
  113.     wadinfo_t           wad;
  114.  
  115. /*
  116.    self->pathname = malloc(strlen(path)+1);
  117.    strcpy (self->pathname, path);
  118.  */
  119.  
  120. /*      info = [[Storage alloc] initCount: 0 elementSize: sizeof(lumpinfo_t) description: ""]; */
  121.     wad_i.info = (STORAGE *) SafeMalloc(sizeof(STORAGE));
  122.     wad_i.info -> data = (lumpinfo_t *) SafeMalloc(sizeof(lumpinfo_t));
  123.     wad_i.info -> size = sizeof(lumpinfo_t);
  124.     wad_i.info -> count = 0;
  125.  
  126.     wad_i.dirty = true;
  127. /*
  128.    self->handle = open (self->pathname, O_CREAT | O_TRUNC | O_RDWR, 0666);
  129.    if (self->handle== -1)
  130.    return NULL;
  131.  */
  132. /* leave space for wad header */
  133. /*      write (self->handle, &wad, sizeof(wad)); */
  134.     fwrite(&wad, sizeof(wad), 1, wad_i.handle);
  135.  
  136.     return;
  137. }
  138.  
  139. /* WADFILE *WadfileClose(WADFILE *self) */
  140. void                WadfileClose(void)
  141. {
  142. /* close (self->handle); */
  143.     fclose(wad_i.handle);
  144.     return;
  145. }
  146.  
  147. /* void WadfileFree(WADFILE *self) */
  148. void                WadfileFree(void)
  149. {
  150. /*
  151.    close (handle);
  152.    [info free];
  153.    free (self->pathname);
  154.    return [super free];
  155.  */
  156.     fclose(wad_i.handle);
  157.     free(wad_i.info -> data);
  158.     free(wad_i.info);
  159.     free(wad_i.pathname);
  160. }
  161.  
  162. /*
  163.    =============================================================================
  164.  */
  165.  
  166. /* int numLumps(WADFILE *self) */
  167. int                 numLumps(void)
  168. {
  169. /*      return [info count]; */
  170.     return wad_i.info -> count;
  171. }
  172.  
  173. /* int lumpsize(WADFILE *self,int lump) */
  174. int                 lumpsize(int lump)
  175. {
  176.     lumpinfo_t         *inf;
  177.  
  178. /*
  179.    inf = [info elementAt: lump];
  180.    return inf->size;
  181.  */
  182.     inf = wad_i.info -> data;
  183.     inf += lump;
  184.     return inf -> size;
  185. }
  186.  
  187. /* int lumpstart(WADFILE *self,int lump) */
  188. int                 lumpstart(int lump)
  189. {
  190.     lumpinfo_t         *inf;
  191.  
  192. /*
  193.    inf = [info elementAt: lump];
  194.    return inf->filepos;
  195.  */
  196.     inf = wad_i.info -> data;
  197.     inf += lump;
  198.     return inf -> filepos;
  199. }
  200.  
  201. /* char const *lumpname(WADFILE *self,int lump) */
  202. char const         *lumpname(int lump)
  203. {
  204.     lumpinfo_t         *inf;
  205.  
  206. /*
  207.    inf = [info elementAt: lump];
  208.    return inf->name;
  209.  */
  210.     inf = wad_i.info -> data;
  211.     inf += lump;
  212.     return inf -> name;
  213. }
  214.  
  215. /*
  216.    ================
  217.    =
  218.    = lumpNamed:
  219.    =
  220.    ================
  221.  */
  222.  
  223. /*int lumpNamed(WADFILE *self,char const *name) */
  224. int                 lumpNamed(char const *name)
  225. {
  226.     lumpinfo_t         *inf;
  227.     int                 i,
  228.                         count;
  229.     char                name8[9];
  230.     int                 v1,
  231.                         v2;
  232.  
  233. /* make the name into two integers for easy compares */
  234.  
  235.     memset(name8, 0, 9);
  236.     if (strlen(name) < 9)
  237.         strncpy(name8, name, 9);
  238.     for (i = 0; i < 9; i++)
  239.         name8[i] = toupper(name8[i]);  /* case insensitive */
  240.  
  241.     v1 = *(int *)name8;
  242.     v2 = *(int *)&name8[4];
  243.  
  244.  
  245. /* scan backwards so patch lump files take precedence */
  246.  
  247. /*      count = [info count]; */
  248.     count = wad_i.info -> count;
  249.     for (i = count - 1; i >= 0; i--)
  250.         {
  251. /*              inf = [info elementAt: i]; */
  252.         inf = wad_i.info -> data;
  253.         inf += i;
  254.         if (*(int *)inf -> name == v1 && *(int *)&inf -> name[4] == v2)
  255.             return i;
  256.         }
  257.     return -1;
  258. }
  259.  
  260. /*
  261.    ================
  262.    =
  263.    = loadLump:
  264.    =
  265.    ================
  266.  */
  267.  
  268. /* void *loadLump(WADFILE *self,int lump) */
  269. void               *loadLump(int lump)
  270. {
  271.     lumpinfo_t         *inf;
  272.     byte               *buf;
  273.  
  274. /*
  275.    inf = [info elementAt: lump];
  276.    buf = malloc (inf->size);
  277.  
  278.    lseek (handle, inf->filepos, L_SET);
  279.    read (handle, buf, inf->size);
  280.  */
  281.     inf = wad_i.info -> data;
  282.     inf += lump;
  283.     buf = (byte *) malloc(inf -> size);
  284. /*
  285.    lseek(self->handle, inf->filepos, SEEK_SET);
  286.    read(self->handle, buf, inf->size);
  287.  */
  288.     fseek(wad_i.handle, inf -> filepos, SEEK_SET);
  289.     fread(buf, inf -> size, 1, wad_i.handle);
  290.  
  291.     return buf;
  292. }
  293.  
  294. /* void *loadLumpNamed(WADFILE *self,char const *name) */
  295. void               *loadLumpNamed(char const *name)
  296. {
  297. /*      return [self loadLump:[self lumpNamed: name]]; */
  298.     return loadLump(lumpNamed(name));
  299. }
  300.  
  301. /*
  302.    ============================================================================
  303.  */
  304.  
  305. /*
  306.    ================
  307.    =
  308.    = addName:data:size:
  309.    =
  310.    ================
  311.  */
  312.  
  313. /* WADFILE *addName(WADFILE *self,char const *name, void *data, int size) */
  314. void                addName(char const *name, void *data, int size)
  315. {
  316.     int                 i;
  317.     lumpinfo_t         *newlump;
  318.  
  319. /*
  320.    if (wad_i.info->count > 0)
  321.    {
  322.    wad_i.info->count += 1;
  323.    wad_i.info->data = (lumpinfo_t *)realloc(wad_i.info->data,
  324.    (wad_i.info->count + 1) * sizeof(lumpinfo_t));
  325.    }
  326.  */
  327.  
  328.     newlump = (lumpinfo_t *) wad_i.info -> data + wad_i.info -> count;
  329.  
  330.     wad_i.dirty = true;
  331.     memset(newlump -> name, 0, sizeof(newlump -> name));
  332.     strncpy(newlump -> name, name, 8);
  333.     for (i = 0; i < 8; i++)
  334.         newlump -> name[i] = toupper(newlump -> name[i]);
  335. /*      newlump->filepos = lseek(self->handle,0, L_XTND); */
  336. /*      newlump->filepos = lseek(self->handle,0,SEEK_END); */
  337.     fseek(wad_i.handle, 0, SEEK_END);
  338.     newlump -> filepos = ftell(wad_i.handle);
  339.     newlump -> size = size;
  340.  
  341. /*      [info addElement: &new]; */
  342.  
  343. /*      write (self->handle, data, size); */
  344.     fwrite(data, size, 1, wad_i.handle);
  345.  
  346.     wad_i.info -> count += 1;
  347.     wad_i.info -> data = (lumpinfo_t *) realloc(wad_i.info -> data,
  348.         (wad_i.info -> count + 1) * sizeof(lumpinfo_t));
  349.  
  350.     return;
  351. }
  352.  
  353.  
  354. /*
  355.    ================
  356.    =
  357.    = writeDirectory:
  358.    =
  359.    char            identification[4];              // should be IWAD
  360.    int             numlumps;
  361.    int             infotableofs;
  362.    ================
  363.  */
  364.  
  365. /* WADFILE *writeDirectory(WADFILE *self) */
  366. void                writeDirectory(void)
  367. {
  368.     wadinfo_t           wad;
  369.     int                 i,
  370.                         count;
  371.     lumpinfo_t         *inf;
  372.  
  373. /*
  374.    write the directory
  375.  */
  376. /*
  377.    count = [info count];
  378.    inf = [info elementAt:0];
  379.  */
  380.     count = wad_i.info -> count;
  381.     inf = wad_i.info -> data;
  382. /*
  383.    for (i=0 ; i<count ; i++)
  384.    {
  385.    inf[i].filepos = LONG (inf[i].filepos);
  386.    inf[i].size = LONG (inf[i].size);
  387.    }
  388.  */
  389. /*      wad.infotableofs = LONG (lseek(self->handle,0, L_XTND)); */
  390. /*      wad.infotableofs = LONG(lseek(self->handle,0,SEEK_END)); */
  391.     fseek(wad_i.handle, 0, SEEK_END);
  392.     wad.infotableofs = ftell(wad_i.handle);
  393.  
  394. /*      write (self->handle, inf, count*sizeof(lumpinfo_t)); */
  395.     fwrite(inf, sizeof(lumpinfo_t), count, wad_i.handle);
  396. /*
  397.    for (i=0 ; i<count ; i++)
  398.    {
  399.    inf[i].filepos = LONG (inf[i].filepos);
  400.    inf[i].size = LONG (inf[i].size);
  401.    }
  402.  */
  403.  
  404. /*
  405.    write the header
  406.  */
  407.     strncpy(wad.identification, "PWAD", 4);
  408. /*      wad.numlumps = LONG ([info count]); */
  409.     wad.numlumps = wad_i.info -> count;
  410. /*
  411.    lseek (self->handle, 0, SEEK_SET);
  412.    write (self->handle, &wad, sizeof(wad));
  413.  */
  414.     fseek(wad_i.handle, 0, SEEK_SET);
  415.     fwrite(&wad, sizeof(wad), 1, wad_i.handle);
  416.  
  417.     return;
  418. }
  419.